home *** CD-ROM | disk | FTP | other *** search
/ Amiga Games: Greatest Hits 1996 / Amiga Games: Greatest Hits 1996.iso / userbox / publicdomain / superplay-lib_dev / programmers / example_spobjects / st / sp_playsubs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-27  |  7.3 KB  |  254 lines
  1.  
  2.  /* SP_PlaySubs.c
  3.     - Functions for Playing ST Files and extraction of Samples from Modules -
  4.     (c) 1992-94 by Andreas R. Kleinert
  5.     Last changes : 11.12.1994
  6.  */
  7.  
  8. #include "spobject.h"
  9.  
  10. ULONG __saveds __asm SPO_Read( register __a1 struct SPObjectHandle *SPObjectHandle_a1);
  11. ULONG __saveds __asm SPO_StartReplay( register __a1 struct SPObjectHandle *SPObjectHandle);
  12. ULONG __saveds __asm SPO_ContinueReplay( register __a1 struct SPObjectHandle *SPObjectHandle_a1);
  13. ULONG __saveds __asm SPO_FastForward( register __a1 struct SPObjectHandle *SPObjectHandle_a1);
  14. ULONG __saveds __asm SPO_FastBackward( register __a1 struct SPObjectHandle *SPObjectHandle_a1);
  15.  
  16. ULONG __saveds __stdargs SPLI_Read(struct SPObjectHandle *SPObjectHandle);
  17.  
  18.  
  19.  /* Globale Variablen */
  20.  
  21. APTR  ST_Module   = N;
  22. ULONG ST_Len      = N;
  23. ULONG ST_RunState = N;
  24.  
  25. ULONG __saveds __asm SPO_Read( register __a1 struct SPObjectHandle *SPObjectHandle_a1)
  26. {
  27.  struct SPObjectHandle *SPObjectHandle = SPObjectHandle_a1;
  28.  
  29.  ULONG           retval        = SPERR_NO_ERROR;
  30.  BPTR            fh            = N;
  31.  
  32.  if(!SPObjectHandle) return(SPERR_NO_HANDLE);
  33.  
  34.  if(fh = Open(SPObjectHandle->ah_ReadName, MODE_OLDFILE))
  35.   {
  36.    retval = SPLI_Read(SPObjectHandle);
  37.    if(!retval)
  38.     {
  39.      struct STHeader *header = (APTR) SPObjectHandle->ah_STModule;
  40.  
  41.      if(!retval)
  42.       {
  43.        if(   (*((ULONG *)&header->st_ID[0]) != ID_MK)
  44.           && (*((ULONG *)&header->st_ID[0]) != ID_MKPlus)
  45.           && (*((ULONG *)&header->st_ID[0]) != ID_FLT4) ) retval = SPERR_UNKNOWN_FILE_FORMAT;
  46.       }
  47.     }
  48.  
  49.    Close(fh);
  50.  
  51.   }else retval = SPERR_FILE_NOT_FOUND;
  52.  
  53.  return(retval);
  54. }
  55.  
  56. ULONG __saveds __asm SPO_StartReplay( register __a1 struct SPObjectHandle *SPObjectHandle_a1)
  57. {
  58.  struct SPObjectHandle *SPObjectHandle = SPObjectHandle_a1;
  59.  
  60.  ULONG retval = SPERR_NO_ERROR;
  61.  
  62.  if(!SPObjectHandle)              return(SPERR_NO_HANDLE);
  63.  if(!SPObjectHandle->ah_STModule) return(SPERR_ILLEGAL_ACCESS);
  64.  
  65.  ST_Start();
  66.  
  67.  return(retval);
  68. }
  69.  
  70. ULONG __saveds __asm SPO_ContinueReplay( register __a1 struct SPObjectHandle *SPObjectHandle_a1)
  71. {
  72.  struct SPObjectHandle *SPObjectHandle = SPObjectHandle_a1;
  73.  ULONG retval = SPERR_NO_ERROR;
  74.  
  75.  if(!SPObjectHandle)              return(SPERR_NO_HANDLE);
  76.  if(!SPObjectHandle->ah_STModule) return(SPERR_ILLEGAL_ACCESS);
  77.  
  78.  if(!ST_IsPlaying()) ST_Start();
  79.  
  80.  return(retval);
  81. }
  82.  
  83. ULONG __saveds __asm SPO_FastForward( register __a1 struct SPObjectHandle *SPObjectHandle_a1)
  84. {
  85.  struct SPObjectHandle *SPObjectHandle = SPObjectHandle_a1;
  86.  ULONG retval = SPERR_NO_ERROR;
  87.  
  88.  if(!SPObjectHandle)              return(SPERR_NO_HANDLE);
  89.  if(!SPObjectHandle->ah_STModule) return(SPERR_ILLEGAL_ACCESS);
  90.  
  91.  retval = SPERR_ACTION_NOT_SUPPORTED;
  92.  
  93.  return(retval);
  94. }
  95.  
  96. ULONG __saveds __asm SPO_FastBackward( register __a1 struct SPObjectHandle *SPObjectHandle_a1)
  97. {
  98.  struct SPObjectHandle *SPObjectHandle = SPObjectHandle_a1;
  99.  ULONG retval = SPERR_NO_ERROR;
  100.  
  101.  if(!SPObjectHandle)              return(SPERR_NO_HANDLE);
  102.  if(!SPObjectHandle->ah_STModule) return(SPERR_ILLEGAL_ACCESS);
  103.  
  104.  retval = SPERR_ACTION_NOT_SUPPORTED;
  105.  
  106.  return(retval);
  107. }
  108.  
  109.  /* sub-routines for XPK, PP and enencoded loading */
  110.  
  111. ULONG __saveds __stdargs SPLI_ReadXPK(struct SPObjectHandle *SPObjectHandle);
  112. ULONG __saveds __stdargs SPLI_ReadPP( struct SPObjectHandle *SPObjectHandle);
  113. ULONG __saveds __stdargs SPLI_ReadDos(struct SPObjectHandle *SPObjectHandle);
  114.  
  115. ULONG __saveds __stdargs SPLI_Read(struct SPObjectHandle *SPObjectHandle)
  116. {
  117.  ULONG *tstptr = (APTR) SPObjectHandle->ah_STModule;
  118.  ULONG  retval = SPERR_NO_ERROR;
  119.  
  120.       if(XpkBase) retval = SPLI_ReadXPK(SPObjectHandle);
  121.  else if(PPBase)  retval = SPLI_ReadPP( SPObjectHandle);
  122.  else             retval = SPLI_ReadDos(SPObjectHandle);
  123.  
  124.  
  125.  /* still packed ? */
  126.  
  127.  if(*tstptr == ID_PP20) retval = SPERR_DECODE_ERROR;
  128.  if(*tstptr == ID_XPKF) retval = SPERR_DECODE_ERROR;
  129.  
  130.  
  131.  /* analyse Sample data, if not ! */
  132.  
  133.  if(!retval)
  134.   {
  135.    SPObjectHandle->ah_SampleList = SPLI_GetSampleList();
  136.    if(SPObjectHandle->ah_SampleList)
  137.     {
  138.      UBYTE           *start    = ((UBYTE *) SPObjectHandle->ah_STModule) + sizeof(struct STHeader);
  139.      struct STHeader *STHeader = (APTR) SPObjectHandle->ah_STModule;
  140.  
  141.      ULONG  len   = N;
  142.      ULONG  add   = N;
  143.      ULONG  j     = N;
  144.  
  145.      for(j=0; j<31; j++)
  146.       {
  147.        len = (STHeader->st_Instruments[j].st_InstrumentLength) << 1;
  148.  
  149.        if(len)
  150.         {
  151.          SPLI_AddSample(SPObjectHandle->ah_SampleList,
  152.                         start + add,
  153.                         len,
  154.                         8,
  155.                         8363,
  156.                         STHeader->st_Instruments[j].st_Volume);
  157.  
  158.          add += len;
  159.         }
  160.       }
  161.     }
  162.   }
  163.  
  164.  return(retval);
  165. }
  166.  
  167. ULONG __saveds __stdargs SPLI_ReadXPK(struct SPObjectHandle *SPObjectHandle)
  168. {
  169.  ULONG           retval        = SPERR_NO_ERROR;
  170.  UBYTE          *Buf           = N;
  171.  ULONG           BufSize       = N;
  172.  struct TagItem  xpk_pars        [6];
  173.  ULONG           xpk_errorcode;
  174.  UBYTE           xpk_errormsg    [XPKERRMSGSIZE + 1];
  175.  
  176.  if(!SPObjectHandle) return(SPERR_NO_HANDLE);
  177.  
  178.  xpk_pars[0].ti_Tag = XPK_GetOutBuf;    xpk_pars[0].ti_Data = (ULONG) &Buf;
  179.  xpk_pars[1].ti_Tag = XPK_GetOutBufLen; xpk_pars[1].ti_Data = (ULONG) &BufSize;
  180.  xpk_pars[2].ti_Tag = XPK_InName;       xpk_pars[2].ti_Data = (ULONG)  SPObjectHandle->ah_ReadName;
  181.  xpk_pars[3].ti_Tag = XPK_GetError;     xpk_pars[3].ti_Data = (ULONG)  xpk_errormsg;
  182.  xpk_pars[4].ti_Tag = XPK_PassThru;     xpk_pars[4].ti_Data = (ULONG)  TRUE;
  183.  xpk_pars[5].ti_Tag = TAG_END;          xpk_pars[5].ti_Data = (ULONG)  N;
  184.  
  185.  xpk_errorcode  = XpkUnpack(&xpk_pars[0]);
  186.  if(!xpk_errorcode)
  187.   {
  188.    SPObjectHandle->ah_STModule = ST_Module = AllocVec(BufSize, (MEMF_CLEAR|MEMF_PUBLIC|MEMF_CHIP));
  189.    if(SPObjectHandle->ah_STModule)
  190.     {
  191.      SPObjectHandle->ah_STLen = ST_Len = BufSize;
  192.  
  193.      CopyMem(Buf, SPObjectHandle->ah_STModule, SPObjectHandle->ah_STLen);
  194.     }else retval = SPERR_NO_MEMORY;
  195.   }else retval = SPERR_DECODE_ERROR;
  196.  
  197.  if(Buf) FreeMem(Buf, BufSize);
  198.  
  199.  return(retval);
  200. }
  201.  
  202. ULONG __saveds __stdargs SPLI_ReadPP(struct SPObjectHandle *SPObjectHandle)
  203. {
  204.  ULONG  retval  = SPERR_NO_ERROR;
  205.  ULONG  code;
  206.  UBYTE *Buf     = N;
  207.  ULONG  BufSize = N;
  208.  
  209.  if(!SPObjectHandle) return(SPERR_NO_HANDLE);
  210.  
  211.  code = ppLoadData(SPObjectHandle->ah_ReadName, DECR_POINTER, N, (APTR) &Buf, (APTR) &BufSize, N);
  212.  if(!code)
  213.   {
  214.    SPObjectHandle->ah_STModule = ST_Module = AllocVec(BufSize, (MEMF_CLEAR|MEMF_PUBLIC|MEMF_CHIP));
  215.    if(SPObjectHandle->ah_STModule)
  216.     {
  217.      SPObjectHandle->ah_STLen = ST_Len = BufSize;
  218.  
  219.      CopyMem(Buf, SPObjectHandle->ah_STModule, SPObjectHandle->ah_STLen);
  220.     }else retval = SPERR_NO_MEMORY;
  221.   }else retval =SPERR_DECODE_ERROR;
  222.  
  223.  if(Buf) FreeMem(Buf, BufSize);
  224.  
  225.  return(retval);
  226. }
  227.  
  228. ULONG __saveds __stdargs SPLI_ReadDos(struct SPObjectHandle *SPObjectHandle)
  229. {
  230.  ULONG retval = SPERR_NO_ERROR;
  231.  BPTR  fh;
  232.  ULONG filesize;
  233.  
  234.  if(!SPObjectHandle) return(SPERR_NO_HANDLE);
  235.  
  236.  if(fh = Open(SPObjectHandle->ah_ReadName, MODE_OLDFILE))
  237.   {
  238.               Seek(fh, N, OFFSET_END); 
  239.    filesize = Seek(fh, N, OFFSET_BEGINNING); 
  240.  
  241.    SPObjectHandle->ah_STModule = ST_Module = AllocVec(filesize, (MEMF_CLEAR|MEMF_PUBLIC|MEMF_CHIP));
  242.    if(SPObjectHandle->ah_STModule)
  243.     {
  244.      SPObjectHandle->ah_STLen = ST_Len = filesize;
  245.  
  246.      Read(fh, SPObjectHandle->ah_STModule, SPObjectHandle->ah_STLen);
  247.     }else retval = SPERR_NO_MEMORY;
  248.  
  249.    Close(fh);
  250.   }else retval = SPERR_FILE_NOT_FOUND;
  251.  
  252.  return(retval);
  253. }
  254.